#ifndef QUEUECORE_H_INCLUDED
#define QUEUECORE_H_INCLUDED

namespace CEngine
{

template<class T>
Queue<T>::Queue(void)
    :   deque()
{}

template<class T>
Queue<T>::Queue(const U64 numberOfElements)
    :   deque(numberOfElements)
{}

template<class T>
Queue<T>::Queue(const U64 numberOfElements, const T& element)
    :   deque(numberOfElements, element)
{}

template<class T>
Queue<T>::Queue(const Queue<T>& queue)
    :   deque(queue.deque)
{}

template<class T>
Queue<T>::Queue(const Deque<T>& deque)
    :   deque(deque)
{}

template<class T>
Queue<T>&
Queue<T>::operator=(const Queue<T>& queue) {
    if(this == &queue) {
        return *this;
    }

    deque = queue.deque;
}

template<class T>
Queue<T>&
Queue<T>::operator=(const Deque<T>& d) {
    if(&deque == &d) {
        return *this;
    }

    deque = d;
}

template<class T>
Queue<T>::~Queue(void) {}

template<class T>
T& Queue<T>::front(void) {
    return deque.front();
}

template<class T>
T& Queue<T>::back(void) {
    return deque.back();
}

template<class T>
void Queue<T>::pushBack(const T& element) {
    deque.pushBack(element);
}

template<class T>
void Queue<T>::popFront(void) {
    deque.popFront();
}

template<class T>
bool Queue<T>::isEmpty(void) const {
    return deque.isEmpty();
}

template<class T>
U64 Queue<T>::getSize(void) const {
    return deque.getSize();
}

}

#endif // QUEUECORE_H_INCLUDED
